﻿using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using EFDataModel.Enums;

namespace EFDataModel
{
    public partial class UserRight : IComparable<UserRight>
    {
        #region static
        /// <summary>
        /// Lokale Liste, die für alle Instanzen zur Verfügung steht, die zum passenden Enum Eintrag die aktuelle DatenbankId speichert.
        /// </summary>
        private static SortedList<EUserRights, long> _userRightsByDbId;
        
        /// <summary>
        /// Gibt die passende Datenbank Id Eintrag für das übergebene EUserRights zurück aus einer Static Liste,
        /// wenn die Liste noch nicht erstellt wurde wird diese automatisch angelegt.
        /// </summary>
        /// <param name="userRight">EUserRights für das die passende DB Id herausgesucht werden soll</param>
        /// <returns>die Passende Datennank Id zum übergenenen Enumwert</returns>
        private static long GetUserRightDbId(EUserRights userRight, EFModelContainer azDataModelContainer)
        {
            //Wenn noch keine RechteIds aus der dB geladen wurden, diese hier laden.
            if (_userRightsByDbId == null && _userRightsByDbId.Count == 0)
            {
                _userRightsByDbId = new SortedList<EUserRights, long>();
                //Alle Rechte in der DB herraussuchen
                var userRights = from eRight in azDataModelContainer.EFCategoryMenge.OfType<UserRight>()
                                 select new {userRightId = eRight.TypeId, dbId = eRight.ID};

                //Alle Rechte durchgehen und alle zur Liste hinzufügen
                foreach (var eRight in userRights)
                {
                    EUserRights eUserRights = (EUserRights) Enum.Parse(typeof (EUserRights), eRight.userRightId.ToString());
                    _userRightsByDbId.Add(eUserRights, eRight.dbId);
                }
            }

            //Die passende Datenbank Id für das UserRight zurückgeben, nach der dann gesucht werden kann.
            return _userRightsByDbId[userRight];
        }

        /// <summary>
        /// Sucht den passenden UserRight anhander des übergebenen Enum Wertes heraus
        /// </summary>
        /// <param name="userRight">UserRight nach dem Enum Value herraussuchen</param>
        /// <param name="azDataModelContainer">Der DataModelContainer der verwendet werden soll für die Suche</param>
        /// <returns>UserRight Object | Null wenn nichts gefunden wurde</returns>
        public static UserRight GetUserRightByRightId(EUserRights userRight , EFModelContainer azDataModelContainer)
        {
            try
            {
                //Erst die passende Datenbank Id ermitteln, dann kann mit der normalen Methode zur Ermittlung des Objektes fortgefahren werden
                return (UserRight)azDataModelContainer.EFCategoryMenge.Find(GetUserRightDbId(userRight, azDataModelContainer));
            }
            catch (Exception)
            {
                return null;
            }
        }

        /// <summary>
        /// Gibt den passenden Namen für den übergebene UserRight zurück
        /// </summary>
        /// <param name="eUserRight">Der Enum Wert zu dem der passende Name herausgesucht werden soll</param>
        /// <returns>String für den Enumwert</returns>
        public static string GetRightName(EUserRights eUserRight)
        {
            return Resources.UserRights.ResourceManager.GetString(eUserRight.ToString());
        }
        #endregion

        #region Public Functions
        /// <summary>
        /// Setzten der passenden UserRightId
        /// </summary>
        public EUserRights EUserRight
        {
            get { return (EUserRights)Enum.Parse(typeof(EUserRights), TypeId.ToString()); }
            set { TypeId = (int)value; }
        }
        #endregion

        /// <summary>
        /// Gibt an, ob das aktuelle Objekt einem anderen Objekt des gleichen Typs entspricht.
        /// </summary>
        /// <returns>
        /// true, wenn das aktuelle Objekt gleich dem <paramref name="other"/>-Parameter ist, andernfalls false.
        /// </returns>
        /// <param name="other">Ein Objekt, das mit diesem Objekt verglichen werden soll.</param>
        public bool Equals(UserRight other)
        {
            if (other.TypeId == this.TypeId)
            {
                return true;
            }

            return false;
        }

        /// <summary>
        /// Gibt den passenden Namen für das aktuelle Recht zurück
        /// </summary>
        /// <returns></returns>
        public string GetRightName()
        {
            return GetRightName(EUserRight);
        }

        /// <summary>
        /// Vergleicht das aktuelle Objekt mit einem anderen Objekt desselben Typs.
        /// Zwei RechteObjekte sind gleich, wenn beide die gleiche TypId haben, es sich also um das gleiche Recht handelt.
        /// </summary>
        /// <returns>
        /// Ein Wert, der die relative Reihenfolge der verglichenen Objekte angibt.Der Rückgabewert hat folgende Bedeutung:Wert Bedeutung Kleiner als 0 (null) Dieses Objekt ist kleiner als der <paramref name="other"/>-Parameter.Zero Dieses Objekt ist gleich <paramref name="other"/>. Größer als 0 (null) Dieses Objekt ist größer als <paramref name="other"/>. 
        /// </returns>
        /// <param name="other">Ein Objekt, das mit diesem Objekt verglichen werden soll.</param>
        public int CompareTo(UserRight other)
        {
            if (other.TypeId == this.TypeId)
            {
                return 0;
            }

            if (other.TypeId < this.TypeId)
            {
                return -1;
            }
            else
            {
                return 1;
            }
        }
    }
}
